﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OffInvoiceExcelAddIn.XmlMngFiles;
using System.Xml.Serialization;
using System.IO;

namespace OffInvoiceExcelAddIn
{
    public partial class InvoiceTaskPane : UserControl
    {
        #region Fields

        /// <summary>
        /// Variable global que referencia al idioma
        /// </summary>
        Language labels;

        /// <summary>
        /// Variable global que referencia al parser que maneja el archivo de gestion de facturas
        /// </summary>
        XmlFileMngParser parser;

        /// <summary>
        /// Variable global que referencia a un registro de factura
        /// </summary>
        XmlInvoiceRecord xmlfilemng = null;

        /// <summary>
        /// Variable que referencia a la clase que define los últimos valores de la búsqueda
        /// </summary>
        LastSearchParameters lastSearchParameters;

        /// <summary>
        /// Variable de tipo string con el áño
        /// </summary>
        string year = "";

        /// <summary>
        /// Variable de tipo string con el mes
        /// </summary>
        string month = "";

        /// <summary>
        /// Variable de tipo string con el estado
        /// </summary>
        string status = "";

        /// <summary>
        /// Variable de tipo string con el nombre del emisor
        /// </summary>
        string issuers = "";

        /// <summary>
        /// Variable de tipo string con el nombre del cliente
        /// </summary>
        string customers = "";

        /// <summary>
        /// Variable de tipo string con el operador
        /// </summary>
        string operador = "";

        /// <summary>
        /// Variable de tipo string con el importe total
        /// </summary>
        string amount = "";

        /// <summary>
        /// Variable de tipo int con el valor del indice del combobox del áño
        /// </summary>
        int yearIndex = -1;

        /// <summary>
        /// Variable de tipo int con el valor del indice del combobox del mes
        /// </summary>
        int monthIndex = -1;

        /// <summary>
        /// Variable de tipo int con el valor del indice del combobox del estado
        /// </summary>
        int statusIndex = -1;

        /// <summary>
        /// Variable de tipo int con el valor del indice del combobox del emisor
        /// </summary>
        int issuerIndex = -1;

        /// <summary>
        /// Variable de tipo int con el valor del indice del combobox del cliente
        /// </summary>
        int customerINdex = -1;

        /// <summary>
        /// Variable de tipo int con el valor del indice del combobox del operador
        /// </summary>
        int operadorIndex = -1;

        string cobrada;
        string pagada;
        string rechazada;

        #endregion

        #region "Constructors"

        /// <summary>
        /// Constructor que inicializa todos los componentes gráficos del control. 
        /// </summary>
        public InvoiceTaskPane()
        {
            InitializeComponent();

        }

        #endregion

        #region "Public Methods"

        /// <summary>
        /// Método que devuelve una referencia del flowlayoutpanel en el que se cargan los controles InvoicePanel
        /// </summary>
        /// <returns></returns>
        public FlowLayoutPanel getFlowLayoutPanel()
        {
            return flpInvoiceContentPanel;
        }

        /// <summary>
        /// Método que actualiza todos los valores del taskpane, cargando los datos, facturas,...
        /// </summary>
        public void updateTaskPane()
        {
            parser = new XmlFileMngParser();
            LoadLanguage();
            cargarComboBox(cbxYear, Globals.ThisAddIn.EnvironmentVariable + Paths.YearsPath);
            cbxIssuers.Items.Clear();
            cbxCostumers.Items.Clear();
            LoadCbxData();
            try
            {
                LoadLastSearchParameters();
                LoadInvoiceListFromAdvancedSearch();
            }
            catch (Exception ex) { };
            habilitarCheckBox();
        }

        /// <summary>
        /// Método que carga el archivo de idioma y establece los textos de los controles
        /// en el idioma que corresponde.
        /// </summary>
        public void LoadLanguage()
        {
            try
            {
                labels = Language.getInstance();
                lbSelec.Text = labels.getLabels(lbSelec.Name);
                lbMonth.Text = labels.getLabels(lbMonth.Name);
                lbYear.Text = labels.getLabels(lbYear.Name);
                lbStatus.Text = labels.getLabels(lbStatus.Name);
                lbIssuers.Text = labels.getLabels(lbIssuers.Name);
                lbCustomers.Text = labels.getLabels(lbCustomers.Name);
                lbAmount.Text = labels.getLabels(lbAmount.Name);
                btnGo.Text = labels.getLabels(btnGo.Name);
                this.cbxMonth.Items.Clear();

                for (int i = 0; i <= 12; i++)
                {
                    this.cbxMonth.Items.Add(labels.getLabels("month" + i));
                }

                this.cbxState.Items.Clear();
                this.cbxState.Items.Add(labels.getLabels("StatusIssued"));
                this.cbxState.Items.Add(labels.getLabels("StatusReceived"));
                this.cbxState.Items.Add(labels.getLabels("StatusDraft"));
                this.cbxState.Refresh();
                ckbCobrada.Text = labels.getLabels(ckbCobrada.Name);
                ckbPagada.Text = labels.getLabels(ckbPagada.Name);
                ckbRechazada.Text = labels.getLabels(ckbRechazada.Name);
            }
            catch (Exception)
            {
                ControlMessages msg = ControlMessages.getInstance();
                MessageBox.Show(msg.getMessage(ControlMessages.Msg.ErrorLoadLanguage), msg.getMessage(ControlMessages.Msg.CaptionActionPane), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }




        }

        /// <summary>
        /// Método que se encarga de mostrar todas las facturas que se han encontrado en la búsqueda en el
        /// flowlayoutpanel
        /// </summary>
        public void LoadInvoiceListView()
        {
            if (xmlfilemng != null)
            {

                for (int i = xmlfilemng.year.month.InvoiceList.Count - 1; i >= 0; i--)
                {
                    XmlInvoice item = xmlfilemng.year.month.InvoiceList[i];
                    InvoicePanel invoicePanel = new InvoicePanel(this, item.Status);

                    invoicePanel.SetSerieNumFac(string.Concat(item.Serie, "-", item.N_factura));
                    invoicePanel.SetNif(item.CIF);

                    invoicePanel.SetDate(item.Fecha);
                    invoicePanel.SetTotal(item.TotalImport);
                    invoicePanel.InvoicePath = item.Path;
                    invoicePanel.setInvoiceType(item.InvoiceType);
                    if (string.IsNullOrEmpty(item.Marca))
                    {
                        invoicePanel.SetMarca(labels.getLabels(item.Status.ToUpper()));
                    }
                    else
                    {
                        invoicePanel.SetMarca(item.Marca.ToUpper().Trim());
                    }

                    if (item.Status.ToUpper().Equals("ISSUED"))
                    {
                        invoicePanel.SetName(string.Concat(item.CustomerName, " ", item.CustomerFirstName, " ", item.CustomerSecondName));
                        invoicePanel.setIssuedContextMenu();
                    }
                    if (item.Status.ToUpper().Equals("RECEIVED"))
                    {
                        invoicePanel.SetName(string.Concat(item.IssuerName, " ", item.IssuerFirstName, " ", item.IssuerSecondName));
                        invoicePanel.setReceivedContextMenu();
                    }
                    if (item.Status.ToUpper().Equals("DRAFT"))
                    {
                        invoicePanel.getLabelINvoiceType().Visible = false;
                        invoicePanel.SetName(string.Concat(item.CustomerName, " ", item.CustomerFirstName, " ", item.CustomerSecondName));
                        invoicePanel.setDraftContextMenu();
                    }

                    flpInvoiceContentPanel.Controls.Add(invoicePanel);

                }


            }
        }

        /// <summary>
        /// Método que se encarga de la búsqueda de las facturas teniendo en cuenta los parámetros
        /// sobre los que quiere filtrar el usuario.
        /// </summary>
        public void LoadInvoiceListFromAdvancedSearch()
        {

            parser = new XmlFileMngParser();

            xmlfilemng = new XmlInvoiceRecord();
            XmlInvoiceRecord mngFile = new XmlInvoiceRecord();

            if (ckbCobrada.Checked)
                cobrada = "COBRADA";
            else
                cobrada = string.Empty;
            if (ckbPagada.Checked)
                pagada = "PAGADA";
            else
                pagada = string.Empty;
            if (ckbRechazada.Checked)
                rechazada = "RECHAZADA";
            else
                rechazada = string.Empty;

            //cbxIssuers.Items.Clear();
            //cbxCostumers.Items.Clear();
            flpInvoiceContentPanel.Controls.Clear();



            if (this.yearIndex > -1 && this.monthIndex >= 0 && this.statusIndex > -1)
            {
                if (monthIndex == 0)
                {
                    xmlfilemng.year.month.InvoiceList = parser.getInvoicesList(statusIndex, customers, issuers, issuerIndex, customerINdex, amount, operadorIndex, cobrada, pagada, rechazada);

                }
                else
                {

                    //TODO: Cambiar this status en un switch para que coja ISSUED,RECEIVED, DRAFT.
                    mngFile = parser.XmlFileMngExist(year, month, monthIndex, ChangeStatus(this.statusIndex));
                    if (mngFile != null)
                    {


                        foreach (XmlInvoice invoice in mngFile.year.month.InvoiceList)
                        {
                            if (parser.getInvoice(invoice, issuers, customers, amount, operadorIndex, issuerIndex, customerINdex, cobrada, pagada, rechazada))
                                xmlfilemng.year.month.InvoiceList.Add(invoice);
                        }
                    }

                }

                LoadInvoiceListView();
            }
            else
            {
                xmlfilemng.year.month.InvoiceList = parser.getInvoicesList(statusIndex, customers, issuers, issuerIndex, customerINdex, amount, operadorIndex, cobrada, pagada, rechazada);
                LoadInvoiceListView();


            }
        }


        /// <summary>
        /// Método que carga los combobox de los emisores y cliente.
        /// Lo que se hace es buscar en todas las facturas los emisores y clientes, si no se han añadido
        /// se añaden y si ya estaban se pasa al siguiente.De esta manera nos apareceran en el combobox de
        /// emisores y clientes los emisores y clientes de los que realmente se tiene alguna factura.
        /// </summary>
        private void LoadCbxData()
        {
            cbxCostumers.Items.Clear();
            cbxIssuers.Items.Clear();

            cbxIssuers.Items.Add(labels.getLabels("lbAll"));
            cbxCostumers.Items.Add(labels.getLabels("lbAll"));

            XmlFileMngRegistry registry = parser.getXmlFileMngRegistry();
            if (registry == null)
            {
                return;
            }
            foreach (XmlFileMngRecord mngFileRec in registry.XmlInvoice)
            {
                if (File.Exists(mngFileRec.Path))
                {
                    XmlInvoiceRecord mngFile = parser.getXmlFileMng(mngFileRec.Path);

                    foreach (XmlInvoice invoice in mngFile.year.month.InvoiceList)
                    {
                        string issuer = string.Concat(invoice.IssuerName, " ", invoice.IssuerFirstName, " ", invoice.IssuerSecondName);
                        if (!exist(cbxIssuers, issuer))
                        {
                            cbxIssuers.Items.Add(issuer);
                        }
                        string customer = string.Concat(invoice.CustomerName, " ", invoice.CustomerFirstName, " ", invoice.CustomerSecondName);
                        if (!exist(cbxCostumers, customer))
                        {
                            cbxCostumers.Items.Add(customer);
                        }

                    }
                }
            }
        }

        /// <summary>
        /// Método que comprueba valores repetidos en un combobox
        /// </summary>
        /// <param name="c">Parámetro de tipo ComboBox con la referencia del combo sobre el que se va a buscar</param>
        /// <param name="s">Parámetro de tipo string con el valor a buscar.</param>
        /// <returns></returns>
        public bool exist(ComboBox c, string s)
        {
            for (int i = 0; i < c.Items.Count; i++)
            {
                if (c.Items[i].Equals(s))
                    return true;
            }
            return false;

        }



        /// <summary>
        /// Método que se encarga de guardar en un archivo los parámetros de la última búsqueda.
        /// De esta manera cada vez que se abra el taskpane aparecerá la última búsqueda realizada.
        /// </summary>
        public void SaveLastSearchParameters()
        {
            try
            {


                //LastSearchParameters lastSearchParameters = new LastSearchParameters(cbxYear.Text, cbxMonth.Text, cbxState.Text, cbxCostumers.Text, cbxIssuers.Text, cbxOper.Text, cbxAmount.Text,cbxOper.SelectedIndex.ToString(),cbxIssuers.SelectedIndex.ToString(),cbxState.SelectedIndex.ToString(),cbxYear.SelectedIndex.ToString(),cbxMonth.SelectedIndex.ToString());
                LastSearchParameters lastSearchParameters = new LastSearchParameters(this.year, this.month, this.status, this.issuers, this.customers, this.operador, this.amount, this.yearIndex.ToString(), this.monthIndex.ToString(), this.statusIndex.ToString(), this.issuerIndex.ToString(), this.customerINdex.ToString(), this.operadorIndex.ToString(), ckbCobrada.Checked.ToString(), ckbPagada.Checked.ToString(), ckbRechazada.Checked.ToString());

                XmlSerializer serializer = new XmlSerializer(typeof(LastSearchParameters));
                System.IO.StreamWriter w = new System.IO.StreamWriter(Globals.ThisAddIn.EnvironmentVariable + Paths.LastSearchParameterPath);
                serializer.Serialize(w, lastSearchParameters);
                w.Close();
            }
            catch (Exception) { }
        }


        /// <summary>
        /// Método que se encarga de cargar los datos de la última búsqueda del archivo que los contiene.
        /// </summary>
        public void GetLastSearchParameters()
        {
            try
            {
                if (System.IO.File.Exists(Globals.ThisAddIn.EnvironmentVariable + Paths.LastSearchParameterPath))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(LastSearchParameters));
                    System.IO.StreamReader r = new System.IO.StreamReader(Globals.ThisAddIn.EnvironmentVariable + Paths.LastSearchParameterPath);
                    lastSearchParameters = (LastSearchParameters)serializer.Deserialize(r);
                    r.Close();
                }
            }
            catch (Exception) { }
        }

        /// <summary>
        /// Método que maneja el evento que se produce al seleccionar un valor del combobox del estado.
        /// Se guarda el texto y el indice en la variable que corresponda
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void cbxState_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.status = cbxState.SelectedItem.ToString();
            this.statusIndex = cbxState.SelectedIndex;
            ckbCobrada.Checked = false;
            ckbRechazada.Checked = false;
            ckbPagada.Checked = false;
            habilitarCheckBox();

        }

        /// <summary>
        /// Método que llama al método que se encarga de buscar los datos de la última búsqueda realizada,
        /// y carga los valores obtenidos el los controles correspondientes. 
        /// </summary>
        public void LoadLastSearchParameters()
        {
            try
            {
                GetLastSearchParameters();

                if (lastSearchParameters != null)
                {

                    cbxYear.SelectedIndex = int.Parse(lastSearchParameters.YearIndex);
                    cbxYear.Text = lastSearchParameters.Year;
                    cbxMonth.SelectedText = lastSearchParameters.Month;
                    cbxMonth.SelectedIndex = int.Parse(lastSearchParameters.MonthIndex);
                    cbxState.SelectedText = lastSearchParameters.State;
                    cbxState.SelectedIndex = int.Parse(lastSearchParameters.StatusIndex);
                    cbxIssuers.SelectedText = lastSearchParameters.Issuers;
                    cbxCostumers.SelectedText = lastSearchParameters.Customers;
                    cbxOper.SelectedText = lastSearchParameters.Operador;
                    cbxAmount.Text = lastSearchParameters.Amount;

                    this.year = lastSearchParameters.Year;
                    this.month = lastSearchParameters.Month;
                    this.status = lastSearchParameters.State;
                    this.issuers = lastSearchParameters.Issuers;
                    this.customers = lastSearchParameters.Customers;
                    this.operador = lastSearchParameters.Operador;
                    this.amount = lastSearchParameters.Amount;
                    this.yearIndex = int.Parse(lastSearchParameters.YearIndex);
                    this.monthIndex = int.Parse(lastSearchParameters.MonthIndex);
                    this.statusIndex = int.Parse(lastSearchParameters.StatusIndex);
                    this.issuerIndex = int.Parse(lastSearchParameters.IssuerIndex);
                    this.customerINdex = int.Parse(lastSearchParameters.CustomerIndex);
                    this.operadorIndex = int.Parse(lastSearchParameters.OperIndex);

                    ckbCobrada.Checked = bool.Parse(lastSearchParameters.Cobrada);
                    ckbPagada.Checked = bool.Parse(lastSearchParameters.Pagada);
                    ckbRechazada.Checked = bool.Parse(lastSearchParameters.Rechazada);



                }
            }
            catch (Exception) { }

        }

        /// <summary>
        /// Método que se encarga de devolver el valor del estado dependiendo del indice.
        /// Este valor es usuado internamente para realizar las búsquedas por los archivos de gestión,
        /// ya que el propio valor del combo no se puede utilizar porque cambiará con el idioma.
        /// </summary>
        /// <param name="index">Parámetro de tipo int con el indice seleccionado </param>
        /// <returns>Un string con el valor</returns>
        public string ChangeStatus(int index)
        {
            switch (index)
            {
                case 0: return "ISSUED";
                case 1: return "RECEIVED";
                case 2: return "DRAFT";
                default:
                    return "ISSUED";
            }
        }



        /// <summary>
        /// Método que busca si hay algún menú contextual abierto y lo cierra.
        /// </summary>
        public void CerrarMenusContextuales()
        {
            for (int i = 0; i < flpInvoiceContentPanel.Controls.Count; i++)
            {
                ((InvoicePanel)flpInvoiceContentPanel.Controls[i]).CerrarContextMenus();
            }
        }



        /// <summary>
        /// Método que se encarga de habilitar y deshabilitar los checkbox dependiendo del estado.
        /// </summary>
        public void habilitarCheckBox()
        {
            if (statusIndex == 0)
            {
                ckbCobrada.Enabled = true;
                ckbRechazada.Enabled = true;
                ckbPagada.Enabled = false;
            }
            if (statusIndex == 1)
            {
                ckbPagada.Enabled = true;
                ckbRechazada.Enabled = true;
                ckbCobrada.Enabled = false;
            }
            if (statusIndex == 2)
            {
                ckbCobrada.Enabled = false;
                ckbPagada.Enabled = false;
                ckbRechazada.Enabled = false;
            }
        }

        #endregion

        #region "Private Methods"

        /// <summary>
        /// Método que maneja el evento que se produce al mostrarse el control.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void InvoiceTaskPane_Load(object sender, EventArgs e)
        {
            updateTaskPane();
        }

        private void lbCustomers_Click(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// Método que carga el combobox que recibe como parámetros con los datos que le corresponden
        /// </summary>
        /// <param name="cbx">Parámetro de tipo ComboBox que referencia al combo que se quiere cargar</param>
        /// <param name="path">Parámetro de tipo string con el path del archivo con los datos</param>
        private void cargarComboBox(ComboBox cbx, string path)
        {
            string[] data = null;
            string datos = string.Empty;

            using (System.IO.StreamReader resourceReader = new System.IO.StreamReader(path))
            {
                if (resourceReader != null)
                {
                    datos = resourceReader.ReadToEnd();
                }
            }

            if (!string.IsNullOrEmpty(datos))
            {
                cbx.Items.Clear();

                try
                {
                    data = datos.Split(',');

                    for (int i = 0; i < data.Length; i++)
                    {
                        cbx.Items.Add(data[i]);

                    }
                }
                catch (Exception) { }
            }
        }

        /// <summary>
        /// Método que maneja el evento que se produce al seleccionar un valor del combobox del año.
        /// Se guarda el texto y el indice en la variable que corresponda
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxYear_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.year = cbxYear.SelectedItem.ToString();
            this.yearIndex = cbxYear.SelectedIndex;
        }

        /// <summary>
        /// Método que maneja el evento que se produce al seleccionar un valor del combobox del mes.
        /// Se guarda el texto y el indice en la variable que corresponda
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxMonth_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.month = cbxMonth.SelectedItem.ToString();
            this.monthIndex = cbxMonth.SelectedIndex;
        }

        /// <summary>
        /// Método que maneja el evento que se produce al hacer click con el raton sobre el botón de Ir.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnGo_Click(object sender, EventArgs e)
        {
            try
            {
                this.amount = cbxAmount.Text;

                SaveLastSearchParameters();

                LoadInvoiceListFromAdvancedSearch();





            }
            catch (Exception) { }
        }

        //private void panel2_Paint(object sender, PaintEventArgs e)
        //{

        //}

        /// <summary>
        /// Método que maneja el evento que se produce al seleccionar un valor del combobox del emisor.
        /// Se guarda el texto y el indice en la variable que corresponda
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxIssuers_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.issuers = cbxIssuers.SelectedItem.ToString();
            this.issuerIndex = cbxIssuers.SelectedIndex;
        }

        /// <summary>
        /// Método que maneja el evento que se produce al seleccionar un valor del combobox del cliente.
        /// Se guarda el texto y el indice en la variable que corresponda
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxCostumers_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.customers = cbxCostumers.SelectedItem.ToString();
            this.customerINdex = cbxCostumers.SelectedIndex;
        }

        /// <summary>
        /// Método que maneja el evento que se produce al seleccionar un valor del combobox del operador.
        /// Se guarda el texto y el indice en la variable que corresponda
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxOper_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.operador = cbxOper.SelectedItem.ToString();
            this.operadorIndex = cbxOper.SelectedIndex;
        }

        private void cbxAmount_TextChanged(object sender, EventArgs e)
        {
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando el texto del combobox de emisores cambia.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxIssuers_TextUpdate(object sender, EventArgs e)
        {
            this.issuers = cbxIssuers.Text;
            this.issuerIndex = -1;
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando el texto del combobox de emisores cambia.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxCostumers_TextUpdate(object sender, EventArgs e)
        {
            this.customers = cbxCostumers.Text;
            this.customerINdex = -1;
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando el texto del combobox de emisores cambia.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxOper_TextUpdate(object sender, EventArgs e)
        {
            this.operador = cbxOper.Text;
            this.operadorIndex = -1;
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando el texto del combobox de estado cambia.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxState_TextUpdate(object sender, EventArgs e)
        {
            this.status = cbxState.Text;
            this.statusIndex = -1;
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando el texto del combobox de mes cambia.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxMonth_TextUpdate(object sender, EventArgs e)
        {
            this.month = cbxMonth.Text;
            this.monthIndex = -1;
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando el texto del combobox de año cambia.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxYear_TextUpdate(object sender, EventArgs e)
        {
            this.year = cbxYear.Text;
            this.yearIndex = -1;
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando se termina de escribir el importe.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxAmount_Leave(object sender, EventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(cbxAmount.Text))
                {
                    double d = double.Parse(cbxAmount.Text);
                }
            }
            catch (Exception)
            {
                ControlMessages msg = ControlMessages.getInstance();
                MessageBox.Show(msg.getMessage(ControlMessages.Msg.MsgAmountNotValid), msg.getMessage(ControlMessages.Msg.CaptionActionPane), MessageBoxButtons.OK, MessageBoxIcon.Information);
                cbxAmount.Text = "";
            }
            this.amount = cbxAmount.Text;
        }


        /// <summary>
        /// Método que maneja el evento que se produce cuando se hace click con el ratón sobre el flowlayoutpanel.
        /// Se encarga de cerrar el menu contextual que esté abierto
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void flpInvoiceContentPanel_Click(object sender, EventArgs e)
        {
            CerrarMenusContextuales();
        }

        /// <summary>
        /// Metodo que maneja el evento que se produce al hacer click con el raton sobre el panel superior.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void panel2_Click(object sender, EventArgs e)
        {
            CerrarMenusContextuales();
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando se selecciona un valor del combo del año
        /// y se hace click en otro control.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxYear_Leave(object sender, EventArgs e)
        {
            try
            {
                if (cbxYear.Text.Length == 4)
                {
                    double d = double.Parse(cbxYear.Text);

                }
                else
                {
                    cbxYear.Text = DateTime.Now.Year.ToString();
                }
            }
            catch (Exception)
            {
                cbxYear.Text = DateTime.Now.Year.ToString();
            }
            if (yearIndex == -1)
            {
                yearIndex = 0;
            }
        }

        /// <summary>
        /// Método que maneja el evento que se produce cuando se selecciona un valor del combo del operador
        /// y se hace click en otro control.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbxOper_Leave(object sender, EventArgs e)
        {
            if (cbxOper.Text != "<" && cbxOper.Text != ">" && cbxOper.Text != "=")
            {
                cbxOper.Text = "";
            }
        }

        #endregion

        private void InvoiceTaskPane_VisibleChanged(object sender, EventArgs e)
        {
            if (this.Visible)
            {
                updateTaskPane();
            }
        }
    }
}
